home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.004 / xemacs-1 / xemacs-19.13 / src / device.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-11  |  21.7 KB  |  575 lines
  1. /* Define device-object for XEmacs.
  2.    Copyright (C) 1994, 1995 Board of Trustees, University of Illinois
  3.    Copyright (C) 1995 Ben Wing
  4.    Copyright (C) 1995 Sun Microsystems
  5.  
  6. This file is part of XEmacs.
  7.  
  8. XEmacs is free software; you can redistribute it and/or modify it
  9. under the terms of the GNU General Public License as published by the
  10. Free Software Foundation; either version 2, or (at your option) any
  11. later version.
  12.  
  13. XEmacs is distributed in the hope that it will be useful, but WITHOUT
  14. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with XEmacs; see the file COPYING.  If not, write to the Free
  20. Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. /* Synched up with: Not in FSF. */
  23.  
  24. /* Written by Chuck Thompson and Ben Wing. */
  25.  
  26. #ifndef _XEMACS_DEVICE_H_
  27. #define _XEMACS_DEVICE_H_
  28.  
  29. struct redisplay_info;
  30. struct device;
  31. struct Lisp_Face;
  32. struct display_line;
  33. struct font_metric_info;
  34. struct window_mirror;
  35. struct scrollbar_instance;
  36.  
  37. /* This should really be in redisplay.h but by putting it here we
  38.    won't have to ensure that redisplay.h is always included before
  39.    this file. */
  40. struct pixel_to_glyph_translation_cache
  41. {
  42.   unsigned int valid :1;
  43.   struct frame *frame;
  44.   int low_x_coord, high_x_coord, col, obj_x;
  45.   int low_y_coord, high_y_coord, row, obj_y;
  46.   struct window *w;
  47.   Bufpos bufpos;
  48.   Bufpos closest;
  49.   Lisp_Object obj;
  50.   int retval;
  51. };
  52.  
  53. struct device_methods
  54. {
  55.   CONST char *name;    /* Used by print_device */
  56.   Lisp_Object symbol;
  57.   Lisp_Object predicate_symbol;
  58.  
  59.   /* device methods */
  60.   void (*init_device_method) (struct device *, Lisp_Object data);
  61.   void (*delete_device_method) (struct device *);
  62.   int (*initially_selected_for_input_method) (struct device *);
  63.   void (*mark_device_method) (struct device *, void (*)(Lisp_Object));
  64.   void (*asynch_device_change_method) ();
  65.   int (*device_pixel_width_method) (struct device *);
  66.   int (*device_pixel_height_method) (struct device *);
  67.   int (*device_mm_width_method) (struct device *);
  68.   int (*device_mm_height_method) (struct device *);
  69.   int (*device_bitplanes_method) (struct device *);
  70.   int (*device_color_cells_method) (struct device *);
  71.  
  72.   /* frame methods */
  73.   Lisp_Object *device_specific_frame_params;
  74.   void (*init_frame_method) (struct frame *, Lisp_Object parameters);
  75.   void (*finish_init_frame_method) (struct frame *, Lisp_Object parameters);
  76.   void (*mark_frame_method) (struct frame *, void (*)(Lisp_Object));
  77.   void (*delete_frame_method) (struct frame *);
  78.   void (*focus_on_frame_method) (struct frame *);
  79.   void (*raise_frame_method) (struct frame *);
  80.   void (*lower_frame_method) (struct frame *);
  81.   int (*get_mouse_position_method) (struct device *, struct window **,
  82.                     int *x, int *y);
  83.   void (*set_mouse_position_method) (struct window *w, int x, int y);
  84.   void (*make_frame_visible_method) (struct frame *f);
  85.   void (*make_frame_invisible_method) (struct frame *f);
  86.   void (*iconify_frame_method) (struct frame *f);
  87.   void (*get_frame_params_method) (struct frame *f, Lisp_Object *alistptr);
  88.   void (*set_frame_params_method) (struct frame *f, Lisp_Object alist);
  89.   void (*set_frame_size_method) (struct frame *f, int width, int height);
  90.   void (*set_frame_position_method) (struct frame *f, int xoff, int yoff);
  91.   int (*frame_totally_visible_p_method) (struct frame *f);
  92.   int (*frame_iconified_p_method) (struct frame *f);
  93.   void (*set_title_from_char_method) (struct frame *f, char *title);
  94.   void (*set_icon_name_from_char_method) (struct frame *f, char *title);
  95.  
  96.   /* color methods */
  97.   int (*initialize_color_instance_method) (struct Lisp_Color_Instance *,
  98.                        Lisp_Object name,
  99.                        Lisp_Object device,
  100.                        int no_error);
  101.   void (*mark_color_instance_method) (struct Lisp_Color_Instance *,
  102.                       void (*)(Lisp_Object));
  103.   void (*print_color_instance_method) (struct Lisp_Color_Instance *,
  104.                        Lisp_Object printcharfun,
  105.                        int escapeflag);
  106.   void (*finalize_color_instance_method) (struct Lisp_Color_Instance *);
  107.   int (*color_instance_equal_method) (struct Lisp_Color_Instance *,
  108.                       struct Lisp_Color_Instance *,
  109.                       int depth);
  110.   unsigned long (*color_instance_hash_method) (struct Lisp_Color_Instance *,
  111.                            int depth);
  112.   Lisp_Object (*color_instance_rgb_components_method)
  113.     (struct Lisp_Color_Instance *);
  114.   int (*valid_color_name_p_method) (struct device *, Lisp_Object color);
  115.  
  116.   /* font methods */
  117.   int (*initialize_font_instance_method) (struct Lisp_Font_Instance *,
  118.                       Lisp_Object name,
  119.                       Lisp_Object device,
  120.                       int no_error);
  121.   void (*mark_font_instance_method) (struct Lisp_Font_Instance *,
  122.                      void (*)(Lisp_Object));
  123.   void (*print_font_instance_method) (struct Lisp_Font_Instance *,
  124.                       Lisp_Object printcharfun,
  125.                       int escapeflag);
  126.   void (*finalize_font_instance_method) (struct Lisp_Font_Instance *);
  127.   Lisp_Object (*font_instance_truename_method) (struct Lisp_Font_Instance *,
  128.                         int no_error);
  129.   Lisp_Object (*font_instance_properties_method) (struct Lisp_Font_Instance *);
  130.   Lisp_Object (*list_fonts_method) (Lisp_Object pattern,
  131.                     Lisp_Object device);
  132.  
  133.   /* image methods */
  134.   void (*mark_image_instance_method) (struct Lisp_Image_Instance *,
  135.                       void (*)(Lisp_Object));
  136.   void (*print_image_instance_method) (struct Lisp_Image_Instance *,
  137.                        Lisp_Object printcharfun,
  138.                        int escapeflag);
  139.   void (*finalize_image_instance_method) (struct Lisp_Image_Instance *);
  140.   int (*image_instance_equal_method) (struct Lisp_Image_Instance *,
  141.                       struct Lisp_Image_Instance *,
  142.                       int depth);
  143.   unsigned long (*image_instance_hash_method) (struct Lisp_Image_Instance *,
  144.                            int depth);
  145.   Lisp_Object image_conversion_list;
  146.  
  147.   /* toolbar methods */
  148.   void (*toolbar_size_changed_in_frame_method) (Lisp_Object specifier,
  149.                         struct frame *f,
  150.                         Lisp_Object oldval);
  151.   void (*output_frame_toolbars_method) (struct frame *);
  152.   void (*initialize_frame_toolbars_method) (struct frame *);
  153.   void (*free_frame_toolbars_method) (struct frame *);
  154.   void (*output_toolbar_button_method) (struct frame *, Lisp_Object);
  155.   void (*redraw_frame_toolbars_method) (struct frame *);
  156.  
  157.   /* scrollbar methods */
  158.   int (*inhibit_scrollbar_thumb_size_change_method) (void);
  159.   void (*free_scrollbar_instance_method) (struct scrollbar_instance *);
  160.   void (*release_scrollbar_instance_method) (struct scrollbar_instance *);
  161.   void (*create_scrollbar_instance_method) (struct frame *, int,
  162.                         struct scrollbar_instance *);
  163.   void (*scrollbar_width_changed_in_frame_method) (Lisp_Object, struct frame *,
  164.                            Lisp_Object);
  165.   void (*scrollbar_height_changed_in_frame_method) (Lisp_Object,
  166.                             struct frame *,
  167.                            Lisp_Object);
  168.   void (*update_scrollbar_instance_values_method) (struct window *,
  169.                            struct scrollbar_instance *,
  170.                            int, int, int, int, int,
  171.                            int, int, int, int, int);
  172.   void (*update_scrollbar_instance_status_method) (struct window *, int, int,
  173.                            struct scrollbar_instance *);
  174.  
  175.   /* redisplay methods */
  176.   void (*update_frame_menubars_method) (struct frame *);
  177.   int (*left_margin_width_method) (struct window *);
  178.   int (*right_margin_width_method) (struct window *);
  179.   int (*text_width_method) (struct window *w, Lisp_Object font,
  180.                 CONST Emchar *, int);
  181.   void (*font_metric_info_method) (struct device *, Lisp_Object font,
  182.                    struct font_metric_info *);
  183.   void (*output_display_block_method) (struct window *, struct display_line *,
  184.                        int, int, int, int, int, int, int);
  185.   int (*divider_width_method) (void);
  186.   int (*divider_height_method) (void);
  187.   int (*eol_cursor_width_method) (void);
  188.   void (*output_vertical_divider_method) (struct window *, int);
  189.   void (*clear_to_window_end_method) (struct window *, int, int);
  190.   void (*clear_region_method) (Lisp_Object, face_index, int, int, int, int);
  191.   void (*clear_frame_method) (struct frame *);
  192.   void (*output_begin_method) (struct device *);
  193.   void (*output_end_method) (struct device *);
  194.   int (*flash_method) (struct device *);
  195.   void (*ring_bell_method) (struct device *, int volume, int pitch,
  196.                 int duration);
  197.   void (*frame_redraw_cursor_method) (struct frame *f);
  198. };
  199.  
  200. #define DEVICE_TYPE_NAME(d) ((d)->methods->name)
  201. #define DEVICE_TYPE(d) ((d)->methods->symbol)
  202. #define DEVICE_SPECIFIC_FRAME_PARAMS(d) \
  203.   ((d)->methods->device_specific_frame_params)
  204.  
  205. /******** Accessing / calling a device method *********/
  206.  
  207. #define HAS_DEVTYPE_METH_P(meth, m) ((meth)->m##_method)
  208. #define DEVTYPE_METH(meth, m, args) (((meth)->m##_method) args)
  209.  
  210. /* Call a void-returning device method, if it exists */
  211. #define MAYBE_DEVTYPE_METH(meth, m, args)            \
  212. do {                                \
  213.   struct device_methods *_maybe_devtype_meth_meth = (meth);    \
  214.   if (HAS_DEVTYPE_METH_P (_maybe_devtype_meth_meth, m))        \
  215.     DEVTYPE_METH (_maybe_devtype_meth_meth, m, args);        \
  216. } while (0)
  217.  
  218. MAC_DECLARE_EXTERN (struct device_methods *, mactemp_devtype_meth_or_given)
  219.  
  220. /* Call a device method, if it exists; otherwise return
  221.    the specified value */
  222. #define DEVTYPE_METH_OR_GIVEN(meth, m, args, given)            \
  223. MAC_BEGIN                                \
  224.   MAC_DECLARE (struct device_methods *,                    \
  225.            mactemp_devtype_meth_or_given, meth)            \
  226.   HAS_DEVTYPE_METH_P (mactemp_devtype_meth_or_given, m) ?        \
  227.     DEVTYPE_METH (mactemp_devtype_meth_or_given, m, args) : (given)    \
  228. MAC_END
  229.  
  230. /* Call an int-returning device method, if it exists; otherwise
  231.    return 0 */
  232. #define MAYBE_INT_DEVTYPE_METH(meth, m, args) \
  233.   DEVTYPE_METH_OR_GIVEN (meth, m, args, 0)
  234.  
  235. /* Call an Lisp-Object-returning device method, if it exists;
  236.    otherwise return Qnil */
  237. #define MAYBE_LISP_DEVTYPE_METH(meth, m, args) \
  238.   DEVTYPE_METH_OR_GIVEN (meth, m, args, Qnil)
  239.  
  240. /******** Same functions, operating on a device instead of a
  241.           struct device_methods ********/
  242.  
  243. #define HAS_DEVMETH_P(d, m) HAS_DEVTYPE_METH_P ((d)->methods, m)
  244. #define DEVMETH(d, m, args) DEVTYPE_METH ((d)->methods, m, args)
  245. #define MAYBE_DEVMETH(d, m, args) MAYBE_DEVTYPE_METH ((d)->methods, m, args)
  246. #define DEVMETH_OR_GIVEN(d, m, args, given) \
  247.   DEVTYPE_METH_OR_GIVEN((d)->methods, m, args, given)
  248. #define MAYBE_INT_DEVMETH(d, m, args) \
  249.   MAYBE_INT_DEVTYPE_METH ((d)->methods, m, args)
  250. #define MAYBE_LISP_DEVMETH(d, m, args) \
  251.   MAYBE_LISP_DEVTYPE_METH ((d)->methods, m, args)
  252.  
  253. /******** Defining new device types ********/
  254.  
  255. #define DECLARE_DEVICE_TYPE(type)                \
  256. extern struct device_methods * type##_device_methods
  257.  
  258. #define DEFINE_DEVICE_TYPE(type)        \
  259. struct device_methods * type##_device_methods;    \
  260. Lisp_Object Q##type
  261.  
  262. #define INITIALIZE_DEVICE_TYPE(type, obj_name, pred_sym)    \
  263.   do {                                \
  264.     type##_device_methods =                    \
  265.       malloc_type_and_zero (struct device_methods);        \
  266.     type##_device_methods->name = obj_name;            \
  267.     defsymbol (&Q##type, obj_name);                \
  268.     type##_device_methods->symbol = Q##type;            \
  269.     defsymbol (&type##_device_methods->predicate_symbol,    \
  270.            pred_sym);                    \
  271.     add_entry_to_device_type_list (Q##type,            \
  272.                    type##_device_methods);    \
  273.     type##_device_methods->image_conversion_list = Qnil;    \
  274.     staticpro (&type##_device_methods->image_conversion_list);    \
  275.   } while (0)
  276.  
  277. /* Declare that device-type TYPE has method M; used in
  278.    initialization routines */
  279. #define DEVICE_HAS_METHOD(type, m) \
  280.   (type##_device_methods->m##_method = type##_##m)
  281.  
  282. struct device
  283. {
  284.   struct lcrecord_header header;
  285.  
  286.   /* Name of this device, for resourcing and printing purposes.
  287.      If not explicitly given, it's initialized in a device-specific
  288.      manner. */
  289.   Lisp_Object name;
  290.  
  291.   /* List of frames on this device. */
  292.   Lisp_Object frame_list;
  293.  
  294.   /* Frame which is "currently selected".  This is what `selected-frame'
  295.      returns and is the default frame for many operations.  This may
  296.      not be the same as frame_with_focus; `select-frame' changes the
  297.      selected_frame but not the frame_with_focus.  However, eventually
  298.      either the two values will be the same, or frame_with_focus will
  299.      be nil: right before waiting for an event, the focus is changed
  300.      to point to the selected_frame if XEmacs currently has the focus
  301.      on this device.  Note that frame_with_focus may be nil (none of the
  302.      frames on this device have the window-system focus), but
  303.      selected_frame will never be nil if there are any frames on
  304.      the device. */
  305.   Lisp_Object selected_frame;
  306.   /* Frame that currently contains the window-manager focus, or none. */
  307.   Lisp_Object frame_with_focus;
  308.   /* If we have recently issued a request to change the focus as a
  309.      result of select-frame having been called, the following variable
  310.      records the frame we are trying to focus on.  The reason for this
  311.      is that the window manager may not grant our request to change
  312.      the focus (so we can't just change frame_with_focus), and we don't
  313.      want to keep sending requests again and again to the window manager.
  314.      This variable is reset whenever a focus-change event is seen. */
  315.   Lisp_Object frame_that_ought_to_have_focus;
  316.  
  317.   /* Type of device.  All frames on a device must be of the same type. */
  318.   struct device_methods *methods;
  319.   Lisp_Object device_class;
  320.  
  321.   /* Really only needed for tty devices.  This maps escape sequences
  322.      generated by function keys. */
  323.   Lisp_Object function_key_map;
  324.  
  325.   /* Alist of values for user-defined tags in this device. */
  326.   Lisp_Object user_defined_tags;
  327.  
  328.   /* Hash tables for device-specific objects (fonts, colors, etc).
  329.      These are key-weak hash tables so that they disappear when the
  330.      key goes away. */
  331.  
  332.   Lisp_Object color_instance_cache;
  333.   Lisp_Object font_instance_cache;
  334.  
  335.   /* The image-instance cache is slightly different.  It is actually
  336.      a bi-level cache, where the hash table in this slot here
  337.      indexes image-instance-type masks (there are currently 6
  338.      image-instance types and thus 64 possible masks) to
  339.      key-weak hash tables like the ones for colors and fonts. */
  340.  
  341.   Lisp_Object image_instance_cache;
  342.  
  343.   /* A structure of auxiliary data specific to the device type.
  344.      struct x_device is used for X window frames; defined in device-x.h
  345.      struct tty_device is used to TTY's; defined in device-tty.h */
  346.   void *device_data;
  347.  
  348.   /* redisplay flags */
  349.   unsigned int buffers_changed :1;
  350.   unsigned int clip_changed :1;
  351.   unsigned int extents_changed :1;
  352.   unsigned int faces_changed :1;
  353.   unsigned int frame_changed :1;
  354.   unsigned int menubar_changed :1;
  355.   unsigned int modeline_changed :1;
  356.   unsigned int point_changed :1;
  357.   unsigned int size_changed :1;
  358.   unsigned int toolbar_changed :1;
  359.   unsigned int windows_changed :1;
  360.   unsigned int windows_structure_changed :1;
  361.  
  362.   unsigned int locked :1;
  363.  
  364.   /* Cache information about last pixel position translated to a
  365.      glyph.  The law of locality applies very heavily here so caching
  366.      the value leads to a significant win.  At the moment this is
  367.      really X specific but once we have generic mouse support it won't
  368.      be. */
  369.   struct pixel_to_glyph_translation_cache pixel_to_glyph_cache;
  370.  
  371.   /* output baud rate of device */
  372.   int baud_rate;
  373.  
  374.   /* Character that causes a quit.  Normally C-g.
  375.      #### Should be possible for this not to be ASCII. */
  376.   int quit_char;
  377.  
  378.   /* File descriptors for input and output.  Much of the time
  379.      (but not always) these will be the same.  For an X device,
  380.      these both hold the file descriptor of the socket used
  381.      to communicate with the X server.  For a TTY device, these
  382.      may or may not be the same and point to the terminal that
  383.      is used for I/O. */
  384.   int infd, outfd;
  385.  
  386.   /* holds some data necessary for SIGIO control.  Perhaps this should
  387.      be inside of device_data; but it is used for both TTY's and X
  388.      devices.  Perhaps it should be conditionalized on SIGIO; but
  389.      this requires including syssignal.h and systty.h. */
  390.   int old_sigio_flag;
  391.   int old_fcntl_owner;
  392.  
  393.   unsigned int input_enabled :1;
  394.  
  395.   /* sound flags */
  396.   unsigned int on_console_p :1;
  397.   unsigned int connected_to_nas_p :1;
  398. };
  399.  
  400. DECLARE_LRECORD (device, struct device);
  401. #define XDEVICE(x) XRECORD (x, device, struct device)
  402. #define XSETDEVICE(x, p) XSETRECORD (x, p, device)
  403. #define DEVICEP(x) RECORDP (x, device)
  404. #define CHECK_DEVICE(x, i) CHECK_RECORD (x, device)
  405.  
  406. #define CHECK_LIVE_DEVICE(x, i)                        \
  407.   do { CHECK_DEVICE (x, i);                        \
  408.        if (! DEVICEP (x)                        \
  409.        || ! DEVICE_LIVE_P (XDEVICE (x)))                \
  410.          x = wrong_type_argument (Qdevice_live_p, (x)); } while (0)
  411.  
  412. #define DEVICE_IS_TYPE(d, type)    EQ (DEVICE_TYPE (d), Q##type)
  413.  
  414. #ifdef ERROR_CHECK_TYPECHECK
  415. MAC_DECLARE_EXTERN (struct device *, mactemp_device_data)
  416. # define DEVICE_TYPE_DATA(d, type)                \
  417. MAC_BEGIN                            \
  418.   MAC_DECLARE (struct device *, mactemp_device_data, d)        \
  419.   assert (DEVICE_IS_TYPE (mactemp_device_data, type))        \
  420.   MAC_SEP                            \
  421.   (struct type##_device *) mactemp_device_data->device_data    \
  422. MAC_END
  423. #else
  424. # define DEVICE_TYPE_DATA(d, type)                \
  425.   ((struct type##_device *) (d)->device_data)
  426. #endif
  427.  
  428. #define CHECK_DEVICE_TYPE(x, i, type)            \
  429.   do {                            \
  430.     CHECK_DEVICE (x, i);                \
  431.     if (!(DEVICEP (x) && DEVICE_IS_TYPE (XDEVICE (x),    \
  432.                      type)))    \
  433.       x = wrong_type_argument                \
  434.     (type##_device_methods->predicate_symbol, x);    \
  435.   } while (0)
  436.  
  437. /* #### These should be in the device-*.h files but there are
  438.    too many places where the abstraction is broken.  Need to
  439.    fix. */
  440.  
  441. #define DEVICE_IS_X(d) DEVICE_IS_TYPE (d, x)
  442. #define CHECK_X_DEVICE(z, i) CHECK_DEVICE_TYPE (z, i, x)
  443.  
  444. #define DEVICE_IS_NS(d) DEVICE_IS_TYPE (d, ns)
  445. #define CHECK_NS_DEVICE(z, i) CHECK_DEVICE_TYPE (z, i, ns)
  446.  
  447. #if defined (HAVE_X_WINDOWS) && defined (HAVE_NEXTSTEP)
  448. #define DEVICE_IS_WIN(d) (DEVICE_IS_X (d) || DEVICE_IS_NS (d))
  449. #elif defined (HAVE_X_WINDOWS)
  450. #define DEVICE_IS_WIN(d) DEVICE_IS_X (d)
  451. #elif defined (HAVE_NEXTSTEP)
  452. #define DEVICE_IS_WIN(d) DEVICE_IS_NS (d)
  453. #else
  454. #define DEVICE_IS_WIN(d) 0
  455. #endif
  456.  
  457. #define DEVICE_IS_TTY(d) DEVICE_IS_TYPE (d, tty)
  458. #define CHECK_TTY_DEVICE(x, i) CHECK_DEVICE_TYPE (x, i, tty)
  459.  
  460. #define DEVICE_IS_STREAM(d) DEVICE_IS_TYPE (d, stream)
  461. #define CHECK_STREAM_DEVICE(x, i) CHECK_DEVICE_TYPE (x, i, stream)
  462.  
  463. extern Lisp_Object Vdevice_list, Vselected_device, Vdefault_device;
  464. extern Lisp_Object Qdelete_device;
  465. extern Lisp_Object Qdevice_live_p;
  466.  
  467. extern Lisp_Object Vdevice_class_list, Vdevice_type_list;
  468.  
  469. extern Lisp_Object Qtty, Qstream, Qdead;
  470. #ifdef HAVE_X_WINDOWS
  471. extern Lisp_Object Qx;
  472. #endif /* HAVE_X_WINDOWS */
  473. #ifdef HAVE_NEXTSTEP
  474. extern Lisp_Object Qns;
  475. #endif /* HAVE_NEXTSTEP */
  476.  
  477. extern Lisp_Object Qcolor, Qgrayscale, Qmono;
  478. extern int valid_device_type_p (Lisp_Object type);
  479. extern int valid_device_class_p (Lisp_Object class);
  480.  
  481. #define DEVICE_LIVE_P(d) (!EQ (DEVICE_TYPE (d), Qdead))
  482.  
  483. #define DEVICE_REDISPLAY_INFO(d) ((d)->redisplay_info)
  484.  
  485. #define DEVICE_NAME(d) ((d)->name)
  486. #define DEVICE_CLASS(d) ((d)->device_class)
  487. #define DEVICE_SELECTED_FRAME(d) ((d)->selected_frame)
  488. #define DEVICE_FRAME_WITH_FOCUS(d) ((d)->frame_with_focus)
  489. #define DEVICE_FRAME_THAT_OUGHT_TO_HAVE_FOCUS(d)            \
  490.   ((d)->frame_that_ought_to_have_focus)
  491. #define DEVICE_FUNCTION_KEY_MAP(d) ((d)->function_key_map)
  492. #define DEVICE_USER_DEFINED_TAGS(d) ((d)->user_defined_tags)
  493. #define DEVICE_FRAME_LIST(d) ((d)->frame_list)
  494. #define DEVICE_BAUD_RATE(d) ((d)->baud_rate)
  495. #define DEVICE_QUIT_CHAR(d) ((d)->quit_char)
  496. #define DEVICE_INFD(d) ((d)->infd)
  497. #define DEVICE_OUTFD(d) ((d)->outfd)
  498. #define DEVICE_OLD_SIGIO_FLAG(d) ((d)->old_sigio_flag)
  499. #define DEVICE_OLD_FCNTL_OWNER(d) ((d)->old_fcntl_owner)
  500. #define DEVICE_ON_CONSOLE_P(d) ((d)->on_console_p)
  501. #define DEVICE_CONNECTED_TO_NAS_P(d) ((d)->connected_to_nas_p)
  502.  
  503. #define LOCK_DEVICE(d) do { (d)->locked = 1; } while (0)
  504. #define UNLOCK_DEVICE(d) do { (d)->locked = 0; } while (0)
  505.  
  506. #define INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE(d)            \
  507.   (d)->pixel_to_glyph_cache.valid = 0
  508.  
  509. #define INVALIDATE_PIXEL_TO_GLYPH_CACHE do {                \
  510.   Lisp_Object dev;                            \
  511.   DEVICE_LOOP (dev)                            \
  512.     INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE (XDEVICE (XCONS (dev)->car)); \
  513.   } while (0)
  514.  
  515. #define MARK_DEVICE_FACES_CHANGED(d) do {                \
  516.   faces_changed = 1;                            \
  517.   (d)->faces_changed = 1; } while (0)
  518.  
  519. #define MARK_DEVICE_TOOLBARS_CHANGED(d) do {                \
  520.   toolbar_changed = 1;                            \
  521.   (d)->toolbar_changed = 1; } while (0)
  522.  
  523. #define MARK_DEVICE_SIZE_CHANGED(d) do {                \
  524.   size_changed = 1;                            \
  525.   (d)->size_changed = 1; } while (0)
  526.  
  527. #define MARK_DEVICE_FRAMES_FACES_CHANGED(d) do {            \
  528.   Lisp_Object frm;                            \
  529.   FRAME_LOOP (frm, d)                            \
  530.     XFRAME (XCONS (frm)->car)->faces_changed = 1;            \
  531.   MARK_DEVICE_FACES_CHANGED (d); } while (0)
  532.  
  533. #define MARK_DEVICE_FRAME_CHANGED(d) do {                \
  534.   frame_changed = 1;                            \
  535.   (d)->frame_changed = 1; } while (0)
  536.  
  537. #define MARK_DEVICE_WINDOWS_CHANGED(d) do {                \
  538.   windows_changed = 1;                            \
  539.   (d)->windows_changed = 1; } while (0)
  540.  
  541. #define MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED(d) do {            \
  542.   windows_structure_changed = 1;                    \
  543.   (d)->windows_structure_changed = 1; } while (0)
  544.  
  545. /* This turns out to be used heavily so we make it a macro to make it
  546.    inline.  Also, the majority of the time the object will turn out to
  547.    be a window so we move it from being checked last to being checked
  548.    first. */
  549. #define DFW_DEVICE(obj)                \
  550.   ((WINDOWP (obj))                \
  551.    ? FRAME_DEVICE (XFRAME (WINDOW_FRAME (XWINDOW (obj)))) \
  552.    : (FRAMEP (obj)                \
  553.       ? FRAME_DEVICE (XFRAME (obj))        \
  554.       : (DEVICEP (obj)                \
  555.      ? obj                    \
  556.      : Qnil)))
  557.  
  558. #define DEVICE_LOOP(var) LIST_LOOP (var, Vdevice_list)
  559.       
  560. extern void select_device_1 (Lisp_Object);
  561. extern Lisp_Object Fselected_device (void);
  562. extern Lisp_Object Fdelete_device (Lisp_Object);
  563. extern Lisp_Object Fdevice_type (Lisp_Object);
  564. extern Lisp_Object Fdevice_name (Lisp_Object);
  565. extern struct device *get_device (Lisp_Object);
  566. extern void handle_asynch_device_change (void);
  567. extern void call_critical_lisp_code (struct device *d, Lisp_Object function,
  568.                      Lisp_Object object);
  569. extern void add_entry_to_device_type_list (Lisp_Object symbol,
  570.                        struct device_methods *type);
  571. extern struct device_methods *decode_device_type (Lisp_Object type,
  572.                           int no_error);
  573.  
  574. #endif /* _XEMACS_DEVICE_H_ */
  575.